/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package ac.persistence;

import ac.entities.Caracteristica;
import ac.entities.Causa;
import ac.entities.Enfermedad;
import ac.entities.Especie;
import ac.entities.Grupo;
import ac.entities.Hecho;
import ac.entities.Lugar;
import ac.entities.NecesidadNutricional;
import ac.entities.Sintoma;
import com.ibatis.sqlmap.client.SqlMapClient;
import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;

/**
 *
 * @author freddy
 */
public class PersistEspecie {

    public boolean insertEspecie (Especie nueva) {
        boolean resultado = false;

        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            sqlMap.insert("insertEspecie", nueva);
            resultado = true;
        } catch (IOException ioe) {
            ioe.printStackTrace();
        } catch (SQLException sqle) {
            sqle.printStackTrace();
        }
        return resultado;
    }

    public int buscarUltimaEspecie() {

        int resultado = 0;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            resultado = (Integer)sqlMap.queryForObject("buscarUltimaEspecie");
        } catch (IOException ioe) {
            System.out.println("Error de Entrada / Salida: " + ioe
                    .getMessage());
            return 0;
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
            return 0;
        } finally {
            return resultado;
        }
    }

    public Especie buscarEspeciePorId(int id){

        Especie especie = null;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            especie =(Especie) sqlMap.queryForObject("buscarEspeciePorId",id);
        } catch (IOException ioe) {
            System.out.println("Error de Entrada/Salida " + ioe.getMessage());
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
        }catch(Exception e){
            e.printStackTrace();
        }
        finally {
            return especie;
        }

    }

    public Lugar buscarLugarPorNombre(String nombre){

        Lugar lugar = null;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            lugar =(Lugar) sqlMap.queryForObject("buscarLugarPorNombre",nombre);
        } catch (IOException ioe) {
            System.out.println("Error de Entrada/Salida " + ioe.getMessage());
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
        }catch(Exception e){
            e.printStackTrace();
        }
        finally {
            return lugar;
        }

    }

    public int buscarUltimoLugar() {

        int resultado = 0;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            resultado = (Integer)sqlMap.queryForObject("buscarUltimoLugar");
        } catch (IOException ioe) {
            System.out.println("Error de Entrada / Salida: " + ioe
                    .getMessage());
            return 0;
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
            return 0;
        } finally {
            return resultado;
        }
    }

    public boolean insertCaracteristica (Caracteristica nueva) {
        boolean resultado = false;

        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            sqlMap.insert("insertCaracteristica", nueva);
            resultado = true;
        } catch (IOException ioe) {
            ioe.printStackTrace();
        } catch (SQLException sqle) {
            sqle.printStackTrace();
        }
        return resultado;
    }

    public int buscarUltimaCaracteristica() {

        int resultado = 0;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            resultado = (Integer)sqlMap.queryForObject("buscarUltimaCaracteristica");
        } catch (IOException ioe) {
            System.out.println("Error de Entrada / Salida: " + ioe
                    .getMessage());
            return 0;
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
            return 0;
        } finally {
            return resultado;
        }
    }

    public Caracteristica buscarCaracteristicaPorId(int id){

        Caracteristica caracteristica = null;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            caracteristica =(Caracteristica) sqlMap.queryForObject("buscarCaracteristicaPorId",id);
        } catch (IOException ioe) {
            System.out.println("Error de Entrada/Salida " + ioe.getMessage());
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
        }catch(Exception e){
            e.printStackTrace();
        }
        finally {
            return caracteristica;
        }

    }

    public boolean insertNecesidad (NecesidadNutricional nueva) {
        boolean resultado = false;

        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            sqlMap.insert("insertNecesidad", nueva);
            resultado = true;
        } catch (IOException ioe) {
            ioe.printStackTrace();
        } catch (SQLException sqle) {
            sqle.printStackTrace();
        }
        return resultado;
    }

    public int buscarUltimaNecesidad() {

        int resultado = 0;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            resultado = (Integer)sqlMap.queryForObject("buscarUltimaNecesidad");
        } catch (IOException ioe) {
            System.out.println("Error de Entrada / Salida: " + ioe
                    .getMessage());
            return 0;
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
            return 0;
        } finally {
            return resultado;
        }
    }

    public NecesidadNutricional buscarNecesidadPorId(int id){

        NecesidadNutricional necesidad = null;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            necesidad =(NecesidadNutricional) sqlMap.queryForObject("buscarNecesidadPorId",id);
        } catch (IOException ioe) {
            System.out.println("Error de Entrada/Salida " + ioe.getMessage());
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
        }catch(Exception e){
            e.printStackTrace();
        }
        finally {
            return necesidad;
        }

    }

    public boolean insertHecho (Hecho nueva) {
        boolean resultado = false;

        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            sqlMap.insert("insertHecho", nueva);
            resultado = true;
        } catch (IOException ioe) {
            ioe.printStackTrace();
        } catch (SQLException sqle) {
            sqle.printStackTrace();
        }
        return resultado;
    }
    
    public boolean insertEnfermedad (Enfermedad nueva) {
        boolean resultado = false;

        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            sqlMap.insert("insertEnfermedad", nueva);
            resultado = true;
        } catch (IOException ioe) {
            ioe.printStackTrace();
        } catch (SQLException sqle) {
            sqle.printStackTrace();
        }
        return resultado;
    }
    
    
    public int buscarUltimaEnfermedad() {

        int resultado = 0;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            resultado = (Integer)sqlMap.queryForObject("buscarUltimaEnfermedad");
        } catch (IOException ioe) {
            System.out.println("Error de Entrada / Salida: " + ioe
                    .getMessage());
            return 0;
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
            return 0;
        } finally {
            return resultado;
        }
    }

    public boolean insertSintoma (Sintoma nueva) {
        boolean resultado = false;

        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            sqlMap.insert("insertSintoma", nueva);
            resultado = true;
        } catch (IOException ioe) {
            ioe.printStackTrace();
        } catch (SQLException sqle) {
            sqle.printStackTrace();
        }
        return resultado;
    }


    public int buscarUltimoSintoma() {

        int resultado = 0;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            resultado = (Integer)sqlMap.queryForObject("buscarUltimoSintoma");
        } catch (IOException ioe) {
            System.out.println("Error de Entrada / Salida: " + ioe
                    .getMessage());
            return 0;
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
            return 0;
        } finally {
            return resultado;
        }
    }

    public Sintoma buscarSintomaPorNombre(String nombre){

        Sintoma lugar = null;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            lugar =(Sintoma) sqlMap.queryForObject("buscarSintomaPorNombre",nombre);
        } catch (IOException ioe) {
            System.out.println("Error de Entrada/Salida " + ioe.getMessage());
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
        }catch(Exception e){
            e.printStackTrace();
        }
        finally {
            return lugar;
        }

    }

    public boolean insertCausa (Causa nueva) {
        boolean resultado = false;

        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            sqlMap.insert("insertCausa", nueva);
            resultado = true;
        } catch (IOException ioe) {
            ioe.printStackTrace();
        } catch (SQLException sqle) {
            sqle.printStackTrace();
        }
        return resultado;
    }


    public int buscarUltimaCausa() {

        int resultado = 0;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            resultado = (Integer)sqlMap.queryForObject("buscarUltimaCausa");
        } catch (IOException ioe) {
            System.out.println("Error de Entrada / Salida: " + ioe
                    .getMessage());
            return 0;
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
            return 0;
        } finally {
            return resultado;
        }
    }

    public Causa buscarCausaPorNombre(String nombre){

        Causa lugar = null;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            lugar =(Causa) sqlMap.queryForObject("buscarCausaPorNombre",nombre);
        } catch (IOException ioe) {
            System.out.println("Error de Entrada/Salida " + ioe.getMessage());
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
        }catch(Exception e){
            e.printStackTrace();
        }
        finally {
            return lugar;
        }

    }

    public Especie buscarEspecieEspañol(String nombre){

        Especie especie = null;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            especie =(Especie) sqlMap.queryForObject("buscarEspeciePorNombre",nombre);
        } catch (IOException ioe) {
            System.out.println("Error de Entrada/Salida " + ioe.getMessage());
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
        }catch(Exception e){
            e.printStackTrace();
        }
        finally {
            return especie;
        }

    }

    public Especie buscarEspecieLatin(String nombre){

        Especie especie = null;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            especie =(Especie) sqlMap.queryForObject("buscarEspeciePorNombreLat",nombre);
        } catch (IOException ioe) {
            System.out.println("Error de Entrada/Salida " + ioe.getMessage());
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
        }catch(Exception e){
            e.printStackTrace();
        }
        finally {
            return especie;
        }

    }

    public ArrayList<Especie> buscarEspecieConvivencia(String nombre){

        ArrayList<Especie> especie = null;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            especie =(ArrayList) sqlMap.queryForList("buscarEspeciePorConvivencia",nombre);
        } catch (IOException ioe) {
            System.out.println("Error de Entrada/Salida " + ioe.getMessage());
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
        }catch(Exception e){
            e.printStackTrace();
        }
        finally {
            return especie;
        }
    }

    public ArrayList<Especie> buscarEspecieAgua(String nombre){

        ArrayList<Especie> especie = null;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            especie =(ArrayList) sqlMap.queryForList("buscarEspeciePorAgua",nombre);
        } catch (IOException ioe) {
            System.out.println("Error de Entrada/Salida " + ioe.getMessage());
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
        }catch(Exception e){
            e.printStackTrace();
        }
        finally {
            return especie;
        }
    }

    public ArrayList<Especie> buscarEspecieCategoria(String nombre){

        ArrayList<Especie> especie = null;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            especie =(ArrayList) sqlMap.queryForList("buscarEspeciePorCategoria",nombre);
        } catch (IOException ioe) {
            System.out.println("Error de Entrada/Salida " + ioe.getMessage());
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
        }catch(Exception e){
            e.printStackTrace();
        }
        finally {
            return especie;
        }
    }

    public boolean updateEspecieDescripcion(String nombre, int id){

        boolean result = false;
        HashMap map = new HashMap();
        map.put("valor", nombre);
        map.put("id", id);
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            sqlMap.update("updateDescripcionEspecie",map);
            result = true;
        } catch (IOException ioe) {
            System.out.println("Error de Entrada/Salida " + ioe.getMessage());
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
        }catch(Exception e){
            e.printStackTrace();
        }
        finally {
            return result;
        }

    }

    public boolean updateEspecieHistoria(String nombre, int id){

        boolean result = false;
        HashMap map = new HashMap();
        map.put("valor", nombre);
        map.put("id", id);
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            sqlMap.update("updateHistoriaEspecie",map);
            result = true;
        } catch (IOException ioe) {
            System.out.println("Error de Entrada/Salida " + ioe.getMessage());
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
        }catch(Exception e){
            e.printStackTrace();
        }
        finally {
            return result;
        }

    }

    public boolean updateEspecieNombre(String nombre, int id){

        boolean result = false;
        HashMap map = new HashMap();
        map.put("valor", nombre);
        map.put("id", id);
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            sqlMap.update("updateNombreEspecie",map);
            result = true;
        } catch (IOException ioe) {
            System.out.println("Error de Entrada/Salida " + ioe.getMessage());
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
        }catch(Exception e){
            e.printStackTrace();
        }
        finally {
            return result;
        }

    }

    public boolean updateEspecieCuarentena(int nombre, int id){

        boolean result = false;
        HashMap map = new HashMap();
        map.put("valor", nombre);
        map.put("id", id);
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            sqlMap.update("updateCuarentenaEspecie",map);
            result = true;
        } catch (IOException ioe) {
            System.out.println("Error de Entrada/Salida " + ioe.getMessage());
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
        }catch(Exception e){
            e.printStackTrace();
        }
        finally {
            return result;
        }

    }

     public ArrayList<Especie> buscarEspecieGrupoTanque(int idTanque){

        ArrayList<Especie> especie = null;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            especie =(ArrayList) sqlMap.queryForList("buscarEspecieGrupoTanque",idTanque);
        } catch (IOException ioe) {
            System.out.println("Error de Entrada/Salida " + ioe.getMessage());
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
        }catch(Exception e){
            e.printStackTrace();
        }
        finally {
            return especie;
        }
    }

     public ArrayList<Grupo> buscarGruposPorTanque(int idTanque){

        ArrayList<Grupo> grupos = null;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            grupos =(ArrayList) sqlMap.queryForList("buscarGruposPorTanque",idTanque);
        } catch (IOException ioe) {
            System.out.println("Error de Entrada/Salida " + ioe.getMessage());
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
        }catch(Exception e){
            e.printStackTrace();
        }
        finally {
            return grupos;
        }
    }

     public Especie buscarEspecieAnimal(int idAnimal){

        Especie especie = null;
        try {
            SqlMapClient sqlMap = SqlConnector.getInstance().getReady();
            especie =(Especie) sqlMap.queryForObject("buscarEspecieAnimal",idAnimal);
        } catch (IOException ioe) {
            System.out.println("Error de Entrada/Salida " + ioe.getMessage());
        } catch (SQLException sqle) {
            System.out.println("Error de SQL: " + sqle.getMessage() + " / "
                                + sqle.getSQLState());
        }catch(Exception e){
            e.printStackTrace();
        }
        finally {
            return especie;
        }

    }
}
